#!/bin/bash

# 本地开发环境启动脚本
set -e

echo "🚀 启动 DevOps SmartBot 本地开发环境"
echo "=================================="

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

log_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# 检查Docker是否运行
check_docker() {
    if ! docker info > /dev/null 2>&1; then
        log_error "Docker未运行，请先启动Docker Desktop"
        exit 1
    fi
    log_success "Docker 运行正常"
}

# 检查端口是否被占用
check_port() {
    local port=$1
    local service=$2
    
    if lsof -Pi :$port -sTCP:LISTEN -t >/dev/null 2>&1; then
        log_warning "端口 $port ($service) 已被占用"
        read -p "是否停止占用端口的进程？(y/n) " -n 1 -r
        echo ""
        if [[ $REPLY =~ ^[Yy]$ ]]; then
            local pid=$(lsof -ti:$port)
            kill -9 $pid 2>/dev/null || true
            log_success "已停止占用端口 $port 的进程"
        fi
    fi
}

# 启动MongoDB
start_mongodb() {
    log_info "启动 MongoDB..."
    
    # 停止并删除已存在的容器
    docker stop mongodb 2>/dev/null || true
    docker rm mongodb 2>/dev/null || true
    
    # 尝试不同的镜像源
    local images=(
        "mongo:6"
        "mongo:latest"
        "bitnami/mongodb:latest"
    )
    
    for image in "${images[@]}"; do
        log_info "尝试拉取镜像: $image"
        if docker pull $image > /dev/null 2>&1; then
            log_success "成功拉取镜像: $image"
            
            # 启动MongoDB容器
            docker run -d \
                --name mongodb \
                -p 27017:27017 \
                -e MONGO_INITDB_ROOT_USERNAME=admin \
                -e MONGO_INITDB_ROOT_PASSWORD=admin123 \
                -v mongodb_data:/data/db \
                $image
            
            # 等待MongoDB启动
            log_info "等待 MongoDB 启动..."
            sleep 5
            
            # 验证连接
            if docker exec mongodb mongosh --eval "db.adminCommand('ismaster')" --quiet > /dev/null 2>&1; then
                log_success "MongoDB 启动成功: mongodb://admin:admin123@localhost:27017"
                return 0
            fi
        fi
    done
    
    log_error "MongoDB 启动失败，尝试其他方案..."
    return 1
}

# 启动Redis
start_redis() {
    log_info "启动 Redis..."
    
    # 停止并删除已存在的容器
    docker stop redis 2>/dev/null || true
    docker rm redis 2>/dev/null || true
    
    # 尝试不同的镜像源
    local images=(
        "redis:7-alpine"
        "redis:latest"
        "bitnami/redis:latest"
    )
    
    for image in "${images[@]}"; do
        log_info "尝试拉取镜像: $image"
        if docker pull $image > /dev/null 2>&1; then
            log_success "成功拉取镜像: $image"
            
            # 启动Redis容器
            if [[ $image == "bitnami/redis:latest" ]]; then
                # Bitnami Redis需要特殊配置
                docker run -d \
                    --name redis \
                    -p 6379:6379 \
                    -e ALLOW_EMPTY_PASSWORD=yes \
                    -v redis_data:/bitnami/redis/data \
                    $image
            else
                # 标准Redis配置
                docker run -d \
                    --name redis \
                    -p 6379:6379 \
                    -v redis_data:/data \
                    $image redis-server --appendonly yes
            fi
            
            # 等待Redis启动
            log_info "等待 Redis 启动..."
            sleep 3
            
            # 验证连接
            if docker exec redis redis-cli ping > /dev/null 2>&1; then
                log_success "Redis 启动成功: redis://localhost:6379"
                return 0
            fi
        fi
    done
    
    log_error "Redis 启动失败，尝试其他方案..."
    return 1
}

# 创建环境配置文件
create_env_files() {
    log_info "创建环境配置文件..."
    
    # 后端环境配置
    if [ ! -f "./backend/.env" ]; then
        cp ./backend/.env.example ./backend/.env
        
        # 生成随机 JWT 密钥
        if command -v openssl > /dev/null; then
            JWT_SECRET=$(openssl rand -hex 32)
            sed -i.bak "s/your-super-secret-jwt-key-change-this-in-production/$JWT_SECRET/g" ./backend/.env
            rm ./backend/.env.bak 2>/dev/null || true
        fi
        
        log_success "后端环境配置文件已创建"
    fi
    
    # 前端环境配置
    if [ ! -f "./frontend/.env" ]; then
        cat > ./frontend/.env << EOF
REACT_APP_API_URL=http://localhost:8000/api
REACT_APP_WS_URL=http://localhost:8000
REACT_APP_VERSION=1.0.0
EOF
        log_success "前端环境配置文件已创建"
    fi
}

# 安装依赖
install_dependencies() {
    log_info "安装项目依赖..."
    
    # 检查Node.js
    if ! command -v node > /dev/null; then
        log_error "Node.js 未安装，请先安装 Node.js 18+"
        exit 1
    fi
    
    # 安装后端依赖
    if [ ! -d "./backend/node_modules" ]; then
        log_info "安装后端依赖..."
        cd backend
        npm install
        cd ..
        log_success "后端依赖安装完成"
    fi
    
    # 安装前端依赖
    if [ ! -d "./frontend/node_modules" ]; then
        log_info "安装前端依赖..."
        cd frontend
        npm install
        cd ..
        log_success "前端依赖安装完成"
    fi
}

# 启动应用服务
start_app() {
    log_info "启动应用服务..."
    
    # 启动后端
    log_info "启动后端服务..."
    cd backend
    npm run dev > ../backend.log 2>&1 &
    BACKEND_PID=$!
    cd ..
    
    # 等待后端启动
    sleep 5
    
    # 检查后端是否启动成功
    if curl -f -s http://localhost:8000/health > /dev/null; then
        log_success "后端服务启动成功: http://localhost:8000"
    else
        log_warning "后端服务可能启动失败，请检查日志: tail -f backend.log"
    fi
    
    # 启动前端
    log_info "启动前端服务..."
    cd frontend
    npm run dev > ../frontend.log 2>&1 &
    FRONTEND_PID=$!
    cd ..
    
    # 保存PID到文件
    echo $BACKEND_PID > .backend.pid
    echo $FRONTEND_PID > .frontend.pid
    
    log_success "前端服务启动中: http://localhost:3000"
}

# 显示状态信息
show_status() {
    echo ""
    echo "🎉 DevOps SmartBot 本地环境启动完成！"
    echo "======================================="
    echo ""
    echo "📱 前端应用:    http://localhost:3000"
    echo "🔧 后端 API:    http://localhost:8000"
    echo "🗄️  MongoDB:     mongodb://admin:admin123@localhost:27017"
    echo "📦 Redis:       redis://localhost:6379"
    echo ""
    echo "📋 管理命令:"
    echo "   查看后端日志: tail -f backend.log"
    echo "   查看前端日志: tail -f frontend.log"
    echo "   停止服务:     ./scripts/stop-local.sh"
    echo ""
    echo "🔐 默认登录信息:"
    echo "   用户名: admin"
    echo "   密码:   admin123"
    echo ""
}

# 创建停止脚本
create_stop_script() {
    cat > ./scripts/stop-local.sh << 'EOF'
#!/bin/bash

echo "🛑 停止 DevOps SmartBot 本地服务..."

# 停止应用进程
if [ -f .backend.pid ]; then
    BACKEND_PID=$(cat .backend.pid)
    kill $BACKEND_PID 2>/dev/null || true
    rm .backend.pid
    echo "✅ 后端服务已停止"
fi

if [ -f .frontend.pid ]; then
    FRONTEND_PID=$(cat .frontend.pid)
    kill $FRONTEND_PID 2>/dev/null || true
    rm .frontend.pid
    echo "✅ 前端服务已停止"
fi

# 停止Docker容器
docker stop mongodb redis 2>/dev/null || true
echo "✅ 数据库服务已停止"

echo "🎉 所有服务已停止"
EOF
    chmod +x ./scripts/stop-local.sh
}

# 主函数
main() {
    check_docker
    check_port 27017 "MongoDB"
    check_port 6379 "Redis"
    check_port 8000 "后端"
    check_port 3000 "前端"
    
    create_env_files
    
    # 启动数据库
    if ! start_mongodb; then
        log_error "MongoDB 启动失败，请检查网络连接或尝试手动安装 MongoDB"
        exit 1
    fi
    
    if ! start_redis; then
        log_error "Redis 启动失败，请检查网络连接或尝试手动安装 Redis"
        exit 1
    fi
    
    install_dependencies
    start_app
    create_stop_script
    show_status
}

# 错误处理
trap 'log_error "脚本执行失败"' ERR

# 执行主函数
main "$@"